…#508)

Lock down the InferenceLayer abstraction with the proof-of-pattern
single-instance subclass — and prove parity end-to-end against the PR 0
golden. Every subsequent layer (PR 6) and the Predictor orchestrator
(PR 8) follows this template.

Layout:

  sleap_nn/inference/layers/
    configs.py            attrs.frozen PreprocessConfig + PostprocessConfig
    base.py               InferenceLayer ABC: preprocess / postprocess /
                          predict / __call__ / warmup. Includes the
                          _to_4d_float_tensor helper that accepts (H,W),
                          (H,W,C), (C,H,W), (B,H,W,C), (B,C,H,W) numpy or
                          torch — gives every subclass a uniform input
                          contract for the new direct-numpy API.
    single_instance.py    SingleInstanceLayer (concrete). Decodes confmaps
                          via ops.peaks.find_global_peaks, applies the
                          full coord ladder via ops.coord, returns Outputs.

End-to-end parity proven by ``test_single_instance_layer_parity_vs_pr0_golden``:
the new layer's pred_keypoints / pred_peak_values match the PR 0 golden
within 1e-5 atol/rtol on the captured fixed input. This test is the
linchpin of the entire refactor — every PR 5–14 will keep gating on it.

Tests (`tests/inference/layers/`, 22 cases):

* InferenceLayer ABC enforcement: cannot instantiate directly; rejects
  non-ModelBackend; predict / __call__ agreement.
* _to_4d_float_tensor: 5 input shapes parametrized + numpy/torch +
  rejection of unsupported types and ranks.
* SingleInstanceLayer:
  - parity vs PR 0 golden (within 1e-5)
  - direct numpy API
  - direct torch API
  - 2D grayscale + 4D batched inputs
  - return_confmaps off-by-default + opt-in populates Outputs.pred_confmaps
  - synthetic-input coord ladder verification (output_stride scaling)

Full inference suite: 240 passed, 8 skipped, 2 xfailed.
Parity regen (RUN_GOLDEN_REGEN_CHECK=1): 30/30 specs match byte-for-byte.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

…513) (#535)

## Summary

Closes #513. Three ops in `sleap_nn/inference/ops` get rewritten to
remove constructs the legacy TorchScript ONNX exporter rejected, while
preserving prior behavior bit-exactly (or within 1 ULP).

## Op rewrites

- **`morphological_dilation`** — replace `Tensor.unfold` with an
explicit 8-shift max stack. Drops the `xfail(strict=True)` marker on its
ONNX-export smoke test from PR 1; that test now passes.
`find_local_peaks_rough` gains exportability as a side effect (was
previously documented as a \"known gap\" expecting a raise; now it
succeeds).

- **`find_global_peaks_rough`** — replace boolean-mask `index_put_`
in-place assignment with `torch.where`. Also splits a single
`squeeze(dim=(2, 3))` into two single-dim `squeeze` calls (the legacy
exporter does not lower the multi-dim form). PR 1's `xfail(strict=True)`
marker dropped; smoke test now passes.

- **`crop_bboxes`** — replace per-peak `unfold` +
advanced-indexing-on-unfolded-view with direct advanced indexing on a
zero-padded image. Bbox top-lefts are floored before extraction
(matching the prior `.to(torch.long)` truncation), so integer-aligned
bboxes produce bit-exact crops; sub-pixel bboxes (centroid-driven
top-down stage 2) reproduce the old \"snap to integer pixel\" behavior
exactly. Avoids the bilinear-interp drift that `F.grid_sample` would
introduce while still removing `unfold`.

## Tests updated

- Drop the two PR 1 `xfail(strict=True)` markers (auto-flipped to
passing)
- Invert `find_local_peaks_rough_known_export_gap` — the function now
exports for fixed-shape examples; test asserts that and verifies output
parity. Variable-peak-count output remains a runtime-shape constraint
that PR 7 (#515) addresses via `find_top_k_peaks`
- Bump `test_golden_is_reproducible` float tolerance from strict zero to
`atol=1e-5`, `rtol=1e-6` to absorb 1-ULP drift from the `torch.where`
rewrite. Two orders of magnitude tighter than the design-doc budget
(1e-4 / 1e-5); integer fields still compared exactly

## CUDA test suite

Bonus: `tests/inference/test_cuda.py` — 12 module-level-skipif-gated
tests covering pure ops, `Outputs` device transfer,
`TorchBackend(device='cuda')`, `SingleInstanceLayer` cross-device
parity, FP16 drift budget, pin_memory transfer correctness. Skip cleanly
on non-CUDA hosts; on a CUDA box run with:

```bash
pytest tests/inference/test_cuda.py -v
```

## Test plan

- [x] `RUN_GOLDEN_REGEN_CHECK=1` — 30/30 specs reproduce within 1e-5 of
PR 0 goldens (subprocess-isolated capture)
- [x] Full inference suite: 242 passed, 8 skipped (CUDA-only) + 12
skipped (CUDA suite), 0 failed, 0 xfailed
- [x] PR 4's `SingleInstanceLayer` parity test still passes at 1e-5
atol/rtol
- [x] Both ONNX-export `xfail` markers from PR 1 dropped — corresponding
tests now pass cleanly

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>